#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
#include <functional>
#include <chrono>

class MainThreadDispatcher {
private:
    std::mutex mtx;
    std::condition_variable cv;
    std::queue<std::function<void()>> main_thread_tasks;
    bool stop_flag = false;
    std::thread::id main_thread_id;

public:
    MainThreadDispatcher() {
        main_thread_id = std::this_thread::get_id();
    }
    
    // 在主线程中处理排队的任务
    void processMainThreadTasks() {
        std::queue<std::function<void()>> tasks_to_process;
        {
            std::lock_guard<std::mutex> lock(mtx);
            tasks_to_process.swap(main_thread_tasks);
        }
        
        // 执行所有排队的主线程任务
        while (!tasks_to_process.empty()) {
            tasks_to_process.front()();
            tasks_to_process.pop();
        }
    }
    
    // 从任何线程调度任务到主线程执行
    void dispatchToMainThread(std::function<void()> task) {
        {
            std::lock_guard<std::mutex> lock(mtx);
            main_thread_tasks.push(task);
        }
        // 通知主线程有新任务（如果需要的话）
    }
    
    // 检查当前是否在主线程中
    bool isMainThread() {
        return std::this_thread::get_id() == main_thread_id;
    }
};

// 全局的主线程调度器
MainThreadDispatcher g_dispatcher;

// 工作线程函数
void workerThreadFunction() {
    std::cout << "Working in worker thread: " << std::this_thread::get_id() << std::endl;
    
    // 模拟一些工作
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    
    // 完成工作后，将结果处理任务调度回主线程
    g_dispatcher.dispatchToMainThread([]() {
        std::cout << "Processing result in main thread: " << std::this_thread::get_id() << std::endl;
        // 在这里可以安全地更新UI或处理需要在主线程完成的任务
    });
}

int main() {
    std::cout << "Main thread ID: " << std::this_thread::get_id() << std::endl;
    
    // 启动工作线程
    std::thread worker(workerThreadFunction);
    
    // 模拟主线程继续运行并定期处理主线程任务
    for (int i = 0; i < 10; ++i) {
        // 处理排队的主线程任务
        g_dispatcher.processMainThreadTasks();
        
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    
    // 等待工作线程完成
    worker.join();
    
    // 最后一次处理剩余的主线程任务
    g_dispatcher.processMainThreadTasks();
    
    return 0;
}